Revista do CD-ROM 101/CD-ROM 101.iso/compl/maya5ple/Install_MayaPLE5_English.exe/Maya/Data1.cab/stdlib.aws

Text File | 2003-07-17 | 38.7 KB | 1,052 lines

// stdlib.aws
//

//--------------------------------------------
// Built-in operators.
//

// operator+ for same types
float operator+ (float f1, float f2);
float2 operator+ (float2 v1, float2 v2);
float3 operator+ (float3 v1, float3 v2);
float4 operator+ (float4 v1, float4 v2);
clampu operator+ (clampu c1, clampu c2);
clampu2 operator+ (clampu2 c1, clampu2 c2);
clampu3 operator+ (clampu3 c1, clampu3 c2);
clampu4 operator+ (clampu4 c1, clampu4 c2);
matrix2 operator+ (matrix2 m1, matrix2 m2);
matrix3 operator+ (matrix3 m1, matrix3 m2);
matrix4 operator+ (matrix4 m1, matrix4 m2);

// operator- for same types
float operator- (float f1, float f2);
float2 operator- (float2 v1, float2 v2);
float3 operator- (float3 v1, float3 v2);
float4 operator- (float4 v1, float4 v2);
clampu operator- (clampu c1, clampu c2);
clampu2 operator- (clampu2 c1, clampu2 c2);
clampu3 operator- (clampu3 c1, clampu3 c2);
clampu4 operator- (clampu4 c1, clampu4 c2);
matrix2 operator- (matrix2 m1, matrix2 m2);
matrix3 operator- (matrix3 m1, matrix3 m2);
matrix4 operator- (matrix4 m1, matrix4 m2);

// operator* for same types
float operator* (float f1, float f2);
float2 operator* (float2 v1, float2 v2);
float3 operator* (float3 v1, float3 v2);
float4 operator* (float4 v1, float4 v2);
clampu operator* (clampu c1, clampu c2);
clampu2 operator* (clampu2 c1, clampu2 c2);
clampu3 operator* (clampu3 c1, clampu3 c2);
clampu4 operator* (clampu4 c1, clampu4 c2);
matrix2 operator* (matrix2 m1, matrix2 m2);
matrix3 operator* (matrix3 m1, matrix3 m2);
matrix4 operator* (matrix4 m1, matrix4 m2);

// operator* by float (symetric)
float2 operator* (float2 v, float f);
float2 operator* (float f, float2 v);
float3 operator* (float3 v, float f);
float3 operator* (float f, float3 v);
float4 operator* (float4 v, float f);
float4 operator* (float f, float4 v);
// clampu?
matrix2 operator* (matrix2 m1, float f);
matrix2 operator* (float f, matrix2 m1);
matrix3 operator* (matrix3 m1, float f);
matrix3 operator* (float f, matrix3 m1);
matrix4 operator* (matrix4 m1, float f);
matrix4 operator* (float f, matrix4 m1);

// Matrix by vector multiplies.
float4 operator* (matrix4 m, float4 v);
float3 operator* (matrix3 m, float3 v);
float2 operator* (matrix2 m, float2 v);

// operator/ for same types
float operator/ (float f1, float f2);
float2 operator/ (float2 v1, float2 v2);
float3 operator/ (float3 v1, float3 v2);
float4 operator/ (float4 v1, float4 v2);
clampu operator/ (clampu c1, clampu c2);
clampu2 operator/ (clampu2 c1, clampu2 c2);
clampu3 operator/ (clampu3 c1, clampu3 c2);
clampu4 operator/ (clampu4 c1, clampu4 c2);
matrix2 operator/ (matrix2 m1, matrix2 m2);
matrix3 operator/ (matrix3 m1, matrix3 m2);
matrix4 operator/ (matrix4 m1, matrix4 m2);

// operator/ by float (right-side only)
float2 operator/ (float2 v, float f);
float3 operator/ (float3 v, float f);
float4 operator/ (float4 v, float f);
// clampu?
matrix2 operator/ (matrix2 m1, float f);
matrix3 operator/ (matrix3 m1, float f);
matrix4 operator/ (matrix4 m1, float f);

// operator% for same types
float operator% (float f1, float f2);
float2 operator% (float2 v1, float2 v2);
float3 operator% (float3 v1, float3 v2);
float4 operator% (float4 v1, float4 v2);
clampu operator% (clampu c1, clampu c2);
clampu2 operator% (clampu2 c1, clampu2 c2);
clampu3 operator% (clampu3 c1, clampu3 c2);
clampu4 operator% (clampu4 c1, clampu4 c2);
matrix2 operator% (matrix2 m1, matrix2 m2);
matrix3 operator% (matrix3 m1, matrix3 m2);
matrix4 operator% (matrix4 m1, matrix4 m2);

// operator% by float (right-side only)
float2 operator% (float2 v, float f);
float3 operator% (float3 v, float f);
float4 operator% (float4 v, float f);
// clampu?
matrix2 operator% (matrix2 m1, float f);
matrix3 operator% (matrix3 m1, float f);
matrix4 operator% (matrix4 m1, float f);

// Swizzle operator
float  operator@ (float  i, constant int  s);
float  operator@ (float2 i, constant int  s);
float  operator@ (float3 i, constant int  s);
float  operator@ (float4 i, constant int  s);
float2 operator@ (float  i, constant int2 s);
float2 operator@ (float2 i, constant int2 s);
float2 operator@ (float3 i, constant int2 s);
float2 operator@ (float4 i, constant int2 s);
float3 operator@ (float  i, constant int3 s);
float3 operator@ (float2 i, constant int3 s);
float3 operator@ (float3 i, constant int3 s);
float3 operator@ (float4 i, constant int3 s);
float4 operator@ (float  i, constant int4 s);
float4 operator@ (float2 i, constant int4 s);
float4 operator@ (float3 i, constant int4 s);
float4 operator@ (float4 i, constant int4 s);
clampu  operator@ (clampu  i, constant int  s);
clampu  operator@ (clampu2 i, constant int  s);
clampu  operator@ (clampu3 i, constant int  s);
clampu  operator@ (clampu4 i, constant int  s);
clampu2 operator@ (clampu  i, constant int2 s);
clampu2 operator@ (clampu2 i, constant int2 s);
clampu2 operator@ (clampu3 i, constant int2 s);
clampu2 operator@ (clampu4 i, constant int2 s);
clampu3 operator@ (clampu  i, constant int3 s);
clampu3 operator@ (clampu2 i, constant int3 s);
clampu3 operator@ (clampu3 i, constant int3 s);
clampu3 operator@ (clampu4 i, constant int3 s);
clampu4 operator@ (clampu  i, constant int4 s);
clampu4 operator@ (clampu2 i, constant int4 s);
clampu4 operator@ (clampu3 i, constant int4 s);
clampu4 operator@ (clampu4 i, constant int4 s);


// Conditional operators
bool operator== (float a, float b);
bool operator!= (float a, float b);
bool operator>  (float a, float b);
bool operator<  (float a, float b);
bool operator>= (float a, float b);
bool operator<= (float a, float b);

bool operator== (clampu a, clampu b);
bool operator!= (clampu a, clampu b);
bool operator>  (clampu a, clampu b);
bool operator<  (clampu a, clampu b);
bool operator>= (clampu a, clampu b);
bool operator<= (clampu a, clampu b);

bool operator&& (bool a, bool b);
bool operator|| (bool a, bool b);

// Computation-frequency promotion typecast operators.
fragment bool     operator fragment(bool i);
fragment float     operator fragment(float i);
fragment float2     operator fragment(float2 i);
fragment float3     operator fragment(float3 i);
fragment float4     operator fragment(float4 i);
fragment float     operator fragment(float i);
fragment float2     operator fragment(float2 i);
fragment float3     operator fragment(float3 i);
fragment float4     operator fragment(float4 i);
fragment matrix2 operator fragment(matrix2 i);
fragment matrix3 operator fragment(matrix3 i);
fragment matrix4 operator fragment(matrix4 i);

vertex bool        operator vertex(constant:vertex bool i);
vertex float    operator vertex(constant:vertex float i);
vertex float2    operator vertex(constant:vertex float2 i);
vertex float3    operator vertex(constant:vertex float3 i);
vertex float4    operator vertex(constant:vertex float4 i);
vertex float    operator vertex(constant:vertex float i);
vertex float2    operator vertex(constant:vertex float2 i);
vertex float3    operator vertex(constant:vertex float3 i);
vertex float4    operator vertex(constant:vertex float4 i);
vertex matrix2    operator vertex(constant:vertex matrix2 i);
vertex matrix3    operator vertex(constant:vertex matrix3 i);
vertex matrix4    operator vertex(constant:vertex matrix4 i);


// Selection operator. Equivalent to "predicate ? a : b".
bool    select(bool p, bool a,      bool b);
float    select(bool p, float a,      float b);
float2    select(bool p, float2 a,  float2 b);
float3    select(bool p, float3 a,  float3 b);
float4    select(bool p, float4 a,  float4 b);
clampu    select(bool p, clampu a,  clampu b);
clampu2    select(bool p, clampu2 a, clampu2 b);
clampu3    select(bool p, clampu3 a, clampu3 b);
clampu4    select(bool p, clampu4 a, clampu4 b);
matrix2 select(bool p, matrix2 a, matrix2 b);
matrix3 select(bool p, matrix3 a, matrix3 b);
matrix4 select(bool p, matrix4 a, matrix4 b);
uniform texobj select(bool p, uniform texobj a,  uniform texobj b);

// Absolute value
float  abs(float a);
float2 abs(float2 a);
float3 abs(float3 a);
float4 abs(float4 a);
clampu  abs(clampu a);
clampu2 abs(clampu2 a);
clampu3 abs(clampu3 a);
clampu4 abs(clampu4 a);





// START BIG SECTION
float  acos( float a );
float2 acos( float2 a );
float3 acos( float3 a );
float4 acos( float4 a );
clampu  acos( clampu a );
clampu2 acos( clampu2 a );
clampu3 acos( clampu3 a );
clampu4 acos( clampu4 a );

float  asin( float a );
float2 asin( float2 a );
float3 asin( float3 a );
float4 asin( float4 a );
clampu  asin( clampu a );
clampu2 asin( clampu2 a );
clampu3 asin( clampu3 a );
clampu4 asin( clampu4 a );

float  atan( float x );
float2 atan( float2 x );
float3 atan( float3 x );
float4 atan( float4 x );
clampu  atan( clampu x );
clampu2 atan( clampu2 x );
clampu3 atan( clampu3 x );
clampu4 atan( clampu4 x );

float  atan2( float y, float x );
float2 atan2( float2 y, float2 x );
float3 atan2( float3 y, float3 x );
float4 atan2( float4 y, float4 x );
clampu  atan2( clampu y, clampu x );
clampu2 atan2( clampu2 y, clampu2 x );
clampu3 atan2( clampu3 y, clampu3 x );
clampu4 atan2( clampu4 y, clampu4 x );

float  ceil( float a );
float2 ceil( float2 a );
float3 ceil( float3 a );
float4 ceil( float4 a );
clampu  ceil( clampu a );
clampu2 ceil( clampu2 a );
clampu3 ceil( clampu3 a );
clampu4 ceil( clampu4 a );

float  clamp( float x, float a, float b );
float2 clamp( float2 x, float2 a, float2 b );
float3 clamp( float3 x, float3 a, float3 b );
float4 clamp( float4 x, float4 a, float4 b );
clampu  clamp( clampu x, clampu a, clampu b );
clampu2 clamp( clampu2 x, clampu2 a, clampu2 b );
clampu3 clamp( clampu3 x, clampu3 a, clampu3 b );
clampu4 clamp( clampu4 x, clampu4 a, clampu4 b );

float  cos( float a );
float2 cos( float2 a );
float3 cos( float3 a );
float4 cos( float4 a );
clampu  cos( clampu a );
clampu2 cos( clampu2 a );
clampu3 cos( clampu3 a );
clampu4 cos( clampu4 a );

float  cosh( float a );
float2 cosh( float2 a );
float3 cosh( float3 a );
float4 cosh( float4 a );
clampu  cosh( clampu a );
clampu2 cosh( clampu2 a );
clampu3 cosh( clampu3 a );
clampu4 cosh( clampu4 a );

float3 cross( float3 a, float3 b );
clampu3 cross( clampu3 a, clampu3 b );

float  ddx( float a );
float2 ddx( float2 a );
float3 ddx( float3 a );
float4 ddx( float4 a );
clampu  ddx( clampu a );
clampu2 ddx( clampu2 a );
clampu3 ddx( clampu3 a );
clampu4 ddx( clampu4 a );

float  ddy( float a );
float2 ddy( float2 a );
float3 ddy( float3 a );
float4 ddy( float4 a );
clampu  ddy( clampu a );
clampu2 ddy( clampu2 a );
clampu3 ddy( clampu3 a );
clampu4 ddy( clampu4 a );

float  degrees( float a );
float2 degrees( float2 a );
float3 degrees( float3 a );
float4 degrees( float4 a );
clampu  degrees( clampu a );
clampu2 degrees( clampu2 a );
clampu3 degrees( clampu3 a );
clampu4 degrees( clampu4 a );

float  dot( float2 a, float2 b );
float  dot( float3 a, float3 b );
float  dot( float4 a, float4 b );
clampu  dot( clampu2 a, clampu2 b );
clampu  dot( clampu3 a, clampu3 b );
clampu  dot( clampu4 a, clampu4 b );

float  exp( float x );
float2 exp( float2 x );
float3 exp( float3 x );
float4 exp( float4 x );
clampu  exp( clampu x );
clampu2 exp( clampu2 x );
clampu3 exp( clampu3 x );
clampu4 exp( clampu4 x );

float  exp2( float x );
float2 exp2( float2 x );
float3 exp2( float3 x );
float4 exp2( float4 x );
clampu  exp2( clampu x );
clampu2 exp2( clampu2 x );
clampu3 exp2( clampu3 x );
clampu4 exp2( clampu4 x );

float  floor( float x );
float2 floor( float2 x );
float3 floor( float3 x );
float4 floor( float4 x );
clampu  floor( clampu x );
clampu2 floor( clampu2 x );
clampu3 floor( clampu3 x );
clampu4 floor( clampu4 x );

float  fmod( float a, float b );
float2 fmod( float2 a, float2 b );
float3 fmod( float3 a, float3 b );
float4 fmod( float4 a, float4 b );
clampu  fmod( clampu a, clampu b );
clampu2 fmod( clampu2 a, clampu2 b );
clampu3 fmod( clampu3 a, clampu3 b );
clampu4 fmod( clampu4 a, clampu4 b );

float  frexp( float x, out float expon );
float2 frexp( float2 x, out float2 expon );
float3 frexp( float3 x, out float3 expon );
float4 frexp( float4 x, out float4 expon );
clampu  frexp( clampu x, out clampu expon );
clampu2 frexp( clampu2 x, out clampu2 expon );
clampu3 frexp( clampu3 x, out clampu3 expon );
clampu4 frexp( clampu4 x, out clampu4 expon );

float  frac( float x );
float2 frac( float2 x );
float3 frac( float3 x );
float4 frac( float4 x );
clampu  frac( clampu x );
clampu2 frac( clampu2 x );
clampu3 frac( clampu3 x );
clampu4 frac( clampu4 x );


// [claforte] Hum... not sure yet if we want those.
// bool   isfinite( float a );
// bool2  isfinite( float2 a );
// bool3  isfinite( float3 a );
// bool4  isfinite( float4 a );
//
// bool   isfinite( clampu a );
// bool2  isfinite( clampu2 a );
// bool3  isfinite( clampu3 a );
// bool4  isfinite( clampu4 a );
//
// bool   isinf( float a );
// bool2  isinf( float2 a );
// bool3  isinf( float3 a );
// bool4  isinf( float4 a );
// bool   isinf( clampu a );
// bool2  isinf( clampu2 a );
// bool3  isinf( clampu3 a );
// bool4  isinf( clampu4 a );
//
// bool   isnan( float a );
// bool2  isnan( float2 a );
// bool3  isnan( float3 a );
// bool4  isnan( float4 a );
// bool   isnan( clampu a );
// bool2  isnan( clampu2 a );
// bool3  isnan( clampu3 a );
// bool4  isnan( clampu4 a );


float  ldexp( float x, float n );
float2 ldexp( float2 x, float2 n );
float3 ldexp( float3 x, float3 n );
float4 ldexp( float4 x, float4 n );
clampu  ldexp( clampu x, clampu n );
clampu2 ldexp( clampu2 x, clampu2 n );
clampu3 ldexp( clampu3 x, clampu3 n );
clampu4 ldexp( clampu4 x, clampu4 n );

float  log( float x );
float2 log( float2 x );
float3 log( float3 x );
float4 log( float4 x );
clampu  log( clampu x );
clampu2 log( clampu2 x );
clampu3 log( clampu3 x );
clampu4 log( clampu4 x );

float  log( float b, float x );
float2 log( float2 b, float2 x );
float3 log( float3 b, float3 x );
float4 log( float4 b, float4 x );
clampu  log( clampu b, clampu x );
clampu2 log( clampu2 b, clampu2 x );
clampu3 log( clampu3 b, clampu3 x );
clampu4 log( clampu4 b, clampu4 x );

float  log2( float x );
float2 log2( float2 x );
float3 log2( float3 x );
float4 log2( float4 x );
clampu  log2( clampu x );
clampu2 log2( clampu2 x );
clampu3 log2( clampu3 x );
clampu4 log2( clampu4 x );

float  log10( float x );
float2 log10( float2 x );
float3 log10( float3 x );
float4 log10( float4 x );
clampu  log10( clampu x );
clampu2 log10( clampu2 x );
clampu3 log10( clampu3 x );
clampu4 log10( clampu4 x );

float  max( float a, float b );
float2 max( float2 a, float2 b );
float3 max( float3 a, float3 b );
float4 max( float4 a, float4 b );
clampu  max( clampu a, clampu b );
clampu2 max( clampu2 a, clampu2 b );
clampu3 max( clampu3 a, clampu3 b );
clampu4 max( clampu4 a, clampu4 b );

float  min( float a, float b );
float2 min( float2 a, float2 b );
float3 min( float3 a, float3 b );
float4 min( float4 a, float4 b );
clampu  min( clampu a, clampu b );
clampu2 min( clampu2 a, clampu2 b );
clampu3 min( clampu3 a, clampu3 b );
clampu4 min( clampu4 a, clampu4 b );

// [claforte] Some of these should probably be complex.
float  mix( float a, float b, float frac );
float2 mix( float2 a, float2 b, float frac );
float3 mix( float3 a, float3 b, float frac );
float4 mix( float4 a, float4 b, float frac );
float2 mix( float2 a, float2 b, float2 frac );
float3 mix( float3 a, float3 b, float3 frac );
float4 mix( float4 a, float4 b, float4 frac );
clampu  mix( clampu a, clampu b, clampu frac );
clampu2 mix( clampu2 a, clampu2 b, clampu frac );
clampu3 mix( clampu3 a, clampu3 b, clampu frac );
clampu4 mix( clampu4 a, clampu4 b, clampu frac );
clampu2 mix( clampu2 a, clampu2 b, clampu2 frac );
clampu3 mix( clampu3 a, clampu3 b, clampu3 frac );
clampu4 mix( clampu4 a, clampu4 b, clampu4 frac );

//  [claforte] Should we support those?
// float  modf( float x, out float ip );
// float2 modf( float2 x, out float2 ip );
// float3 modf( float3 x, out float3 ip );
// float4 modf( float4 x, out float4 ip );
// clampu  modf( clampu x, out clampu ip );
// clampu2 modf( clampu2 x, out clampu2 ip );
// clampu3 modf( clampu3 x, out clampu3 ip );
// clampu4 modf( clampu4 x, out clampu4 ip );


// [claforte] Should probably be complex.
float  noise( float x );
float  noise( float x, float y );
float  noise( float x, float y, float z );
float  noise( float2 x );
float  noise( float3 x );
clampu  noise( clampu x );
clampu  noise( clampu x, clampu y );
clampu  noise( clampu x, clampu y, clampu z );
clampu  noise( clampu2 x );
clampu  noise( clampu3 x );

float  pow( float x, float y );
float2 pow( float2 x, float2 y );
float3 pow( float3 x, float3 y );
float4 pow( float4 x, float4 y );
clampu  pow( clampu x, clampu y );
clampu2 pow( clampu2 x, clampu2 y );
clampu3 pow( clampu3 x, clampu3 y );
clampu4 pow( clampu4 x, clampu4 y );

float  radians( float a );
float2 radians( float2 a );
float3 radians( float3 a );
float4 radians( float4 a );
clampu  radians( clampu a );
clampu2 radians( clampu2 a );
clampu3 radians( clampu3 a );
clampu4 radians( clampu4 a );

float  round( float a );
float2 round( float2 a );
float3 round( float3 a );
float4 round( float4 a );
clampu  round( clampu a );
clampu2 round( clampu2 a );
clampu3 round( clampu3 a );
clampu4 round( clampu4 a );

float  rsqrt( float x );
float2 rsqrt( float2 x );
float3 rsqrt( float3 x );
float4 rsqrt( float4 x );
clampu  rsqrt( clampu x );
clampu2 rsqrt( clampu2 x );
clampu3 rsqrt( clampu3 x );
clampu4 rsqrt( clampu4 x );

float  sign( float a );
float2 sign( float2 a );
float3 sign( float3 a );
float4 sign( float4 a );
clampu  sign( clampu a );
clampu2 sign( clampu2 a );
clampu3 sign( clampu3 a );
clampu4 sign( clampu4 a );

float  sin( float a );
float2 sin( float2 a );
float3 sin( float3 a );
float4 sin( float4 a );
clampu  sin( clampu a );
clampu2 sin( clampu2 a );
clampu3 sin( clampu3 a );
clampu4 sin( clampu4 a );

float  sinh( float a );
float2 sinh( float2 a );
float3 sinh( float3 a );
float4 sinh( float4 a );
clampu  sinh( clampu a );
clampu2 sinh( clampu2 a );
clampu3 sinh( clampu3 a );
clampu4 sinh( clampu4 a );

float  smoothstep( float a, float b, float x );
float2 smoothstep( float2 a, float2 b, float2 x );
float3 smoothstep( float3 a, float3 b, float3 x );
float4 smoothstep( float4 a, float4 b, float4 x );
clampu  smoothstep( clampu a, clampu b, clampu x );
clampu2 smoothstep( clampu2 a, clampu2 b, clampu2 x );
clampu3 smoothstep( clampu3 a, clampu3 b, clampu3 x );
clampu4 smoothstep( clampu4 a, clampu4 b, clampu4 x );

float  step( float a, float x );
float2 step( float2 a, float2 x );
float3 step( float3 a, float3 x );
float4 step( float4 a, float4 x );
clampu  step( clampu a, clampu x );
clampu2 step( clampu2 a, clampu2 x );
clampu3 step( clampu3 a, clampu3 x );
clampu4 step( clampu4 a, clampu4 x );

float  sqrt( float a );
float2 sqrt( float2 a );
float3 sqrt( float3 a );
float4 sqrt( float4 a );
clampu  sqrt( clampu a );
clampu2 sqrt( clampu2 a );
clampu3 sqrt( clampu3 a );
clampu4 sqrt( clampu4 a );

float  tan( float a );
float2 tan( float2 a );
float3 tan( float3 a );
float4 tan( float4 a );
clampu  tan( clampu a );
clampu2 tan( clampu2 a );
clampu3 tan( clampu3 a );
clampu4 tan( clampu4 a );

float  tanh( float a );
float2 tanh( float2 a );
float3 tanh( float3 a );
float4 tanh( float4 a );
clampu  tanh( clampu a );
clampu2 tanh( clampu2 a );
clampu3 tanh( clampu3 a );
clampu4 tanh( clampu4 a );


// Geometrical Prototypes
float distance( float2 pt1, float2 pt2 );
float distance( float3 pt1, float3 pt2 );
float distance( float4 pt1, float4 pt2 );
clampu distance( clampu2 pt1, clampu2 pt2 );
clampu distance( clampu3 pt1, clampu3 pt2 );
clampu distance( clampu4 pt1, clampu4 pt2 );

// [claforte] Should be complex.
float fresnel( float3 i, float3 n, float eta );
float fresnel( float3 i, float3 n, float eta, out float kt );
float fresnel( float3 i, float3 n, float eta, out float kt, out float3 r, out float3 t );
float fresnel( float3 i, float3 n, float eta, out float3 r, out float3 t );
clampu fresnel( clampu3 i, clampu3 n, clampu eta );
clampu fresnel( clampu3 i, clampu3 n, clampu eta, out clampu kt );
clampu fresnel( clampu3 i, clampu3 n, clampu eta, out clampu kt, out clampu3 r, out clampu3 t );
clampu fresnel( clampu3 i, clampu3 n, clampu eta, out clampu3 r, out clampu3 t );

// [claforte] Should be complex.
float length( float2 v );
float length( float3 v );
float length( float4 v );
clampu length( clampu2 v );
clampu length( clampu3 v );
clampu length( clampu4 v );

float2 normalize( float2 v );
float3 normalize( float3 v );
float4 normalize( float4 v );
clampu2 normalize( clampu2 v );
clampu3 normalize( clampu3 v );
clampu4 normalize( clampu4 v );

// Normalize and return the length at the same time.
float2 normalize( float2 v, out float length );
float3 normalize( float3 v, out float length );
float4 normalize( float4 v, out float length );
clampu2 normalize( clampu2 v, out float length );
clampu3 normalize( clampu3 v, out float length );
clampu4 normalize( clampu4 v, out float length );

float3 reflect( float3 i, float3 n );
float3 reflectn( float3 i, float3 n );
clampu3 reflect( clampu3 i, clampu3 n );
clampu3 reflectn( clampu3 i, clampu3 n );

float3 refract( float3 i, float3 n );
float3 refractn( float3 i, float3 n );
clampu3 refract( clampu3 i, clampu3 n );
clampu3 refractn( clampu3 i, clampu3 n );


// Texture functions
fragment float  f1tex1D(uniform texobj tex, float s);                              // 1D non-projective
fragment float2 f2tex1D(uniform texobj tex, float s);                              // 1D non-projective
fragment float3 f3tex1D(uniform texobj tex, float s);                              // 1D non-projective
fragment float4 f4tex1D(uniform texobj tex, float s);                              // 1D non-projective
fragment clampu  x1tex1D(uniform texobj tex, float s);                              // 1D non-projective
fragment clampu2 x2tex1D(uniform texobj tex, float s);                              // 1D non-projective
fragment clampu3 x3tex1D(uniform texobj tex, float s);                              // 1D non-projective
fragment clampu4 x4tex1D(uniform texobj tex, float s);                              // 1D non-projective

fragment float  f1tex1D(uniform texobj tex, float2 sq);                            // 1D projective
fragment float2 f2tex1D(uniform texobj tex, float2 sq);                            // 1D projective
fragment float3 f3tex1D(uniform texobj tex, float2 sq);                            // 1D projective
fragment float4 f4tex1D(uniform texobj tex, float2 sq);                            // 1D projective
fragment clampu  x1tex1D(uniform texobj tex, float2 sq);                            // 1D projective
fragment clampu2 x2tex1D(uniform texobj tex, float2 sq);                            // 1D projective
fragment clampu3 x3tex1D(uniform texobj tex, float2 sq);                            // 1D projective
fragment clampu4 x4tex1D(uniform texobj tex, float2 sq);                            // 1D projective

fragment float  f1tex1D(uniform texobj tex, float s, float dsdx, float dsdy);      // 1D non-proj, w/derivs
fragment float2 f2tex1D(uniform texobj tex, float s, float dsdx, float dsdy);      // 1D non-proj, w/derivs
fragment float3 f3tex1D(uniform texobj tex, float s, float dsdx, float dsdy);      // 1D non-proj, w/derivs
fragment float4 f4tex1D(uniform texobj tex, float s, float dsdx, float dsdy);      // 1D non-proj, w/derivs
fragment clampu  x1tex1D(uniform texobj tex, float s, float dsdx, float dsdy);      // 1D non-proj, w/derivs
fragment clampu2 x2tex1D(uniform texobj tex, float s, float dsdx, float dsdy);      // 1D non-proj, w/derivs
fragment clampu3 x3tex1D(uniform texobj tex, float s, float dsdx, float dsdy);      // 1D non-proj, w/derivs
fragment clampu4 x4tex1D(uniform texobj tex, float s, float dsdx, float dsdy);      // 1D non-proj, w/derivs

fragment float  f1tex2D(uniform texobj tex, float2 s);                             // 2D non-projective
fragment float2 f2tex2D(uniform texobj tex, float2 s);                             // 2D non-projective
fragment float3 f3tex2D(uniform texobj tex, float2 s);                             // 2D non-projective
fragment float4 f4tex2D(uniform texobj tex, float2 s);                             // 2D non-projective
fragment clampu  x1tex2D(uniform texobj tex, float2 s);                             // 2D non-projective
fragment clampu2 x2tex2D(uniform texobj tex, float2 s);                             // 2D non-projective
fragment clampu3 x3tex2D(uniform texobj tex, float2 s);                             // 2D non-projective
fragment clampu4 x4tex2D(uniform texobj tex, float2 s);                             // 2D non-projective

fragment float  f1tex2D(uniform texobj tex, float3 sq);                            // 2D projective
fragment float2 f2tex2D(uniform texobj tex, float3 sq);                            // 2D projective
fragment float3 f3tex2D(uniform texobj tex, float3 sq);                            // 2D projective
fragment float4 f4tex2D(uniform texobj tex, float3 sq);                            // 2D projective
fragment clampu  x1tex2D(uniform texobj tex, float3 sq);                            // 2D projective
fragment clampu2 x2tex2D(uniform texobj tex, float3 sq);                            // 2D projective
fragment clampu3 x3tex2D(uniform texobj tex, float3 sq);                            // 2D projective
fragment clampu4 x4tex2D(uniform texobj tex, float3 sq);                            // 2D projective

fragment float  f1tex2D(uniform texobj tex, float2 s, float2 dsdx, float2 dsdy);   // 2D non-proj, w/derivs
fragment float2 f2tex2D(uniform texobj tex, float2 s, float2 dsdx, float2 dsdy);   // 2D non-proj, w/derivs
fragment float3 f3tex2D(uniform texobj tex, float2 s, float2 dsdx, float2 dsdy);   // 2D non-proj, w/derivs
fragment float4 f4tex2D(uniform texobj tex, float2 s, float2 dsdx, float2 dsdy);   // 2D non-proj, w/derivs
fragment clampu  x1tex2D(uniform texobj tex, float2 s, float2 dsdx, float2 dsdy);   // 2D non-proj, w/derivs
fragment clampu2 x2tex2D(uniform texobj tex, float2 s, float2 dsdx, float2 dsdy);   // 2D non-proj, w/derivs
fragment clampu3 x3tex2D(uniform texobj tex, float2 s, float2 dsdx, float2 dsdy);   // 2D non-proj, w/derivs
fragment clampu4 x4tex2D(uniform texobj tex, float2 s, float2 dsdx, float2 dsdy);   // 2D non-proj, w/derivs

fragment float  f1tex3D(uniform texobj tex, float3 s);                             // 3D non-projective
fragment float2 f2tex3D(uniform texobj tex, float3 s);                             // 3D non-projective
fragment float3 f3tex3D(uniform texobj tex, float3 s);                             // 3D non-projective
fragment float4 f4tex3D(uniform texobj tex, float3 s);                             // 3D non-projective
fragment clampu  x1tex3D(uniform texobj tex, float3 s);                             // 3D non-projective
fragment clampu2 x2tex3D(uniform texobj tex, float3 s);                             // 3D non-projective
fragment clampu3 x3tex3D(uniform texobj tex, float3 s);                             // 3D non-projective
fragment clampu4 x4tex3D(uniform texobj tex, float3 s);                             // 3D non-projective

fragment float  f1tex3D(uniform texobj tex, float4 sq);                            // 3D projective
fragment float2 f2tex3D(uniform texobj tex, float4 sq);                            // 3D projective
fragment float3 f3tex3D(uniform texobj tex, float4 sq);                            // 3D projective
fragment float4 f4tex3D(uniform texobj tex, float4 sq);                            // 3D projective
fragment clampu  x1tex3D(uniform texobj tex, float4 sq);                            // 3D projective
fragment clampu2 x2tex3D(uniform texobj tex, float4 sq);                            // 3D projective
fragment clampu3 x3tex3D(uniform texobj tex, float4 sq);                            // 3D projective
fragment clampu4 x4tex3D(uniform texobj tex, float4 sq);                            // 3D projective

fragment float  f1tex3D(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy);   // 3D non-proj, w/derivs
fragment float2 f2tex3D(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy);   // 3D non-proj, w/derivs
fragment float3 f3tex3D(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy);   // 3D non-proj, w/derivs
fragment float4 f4tex3D(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy);   // 3D non-proj, w/derivs
fragment clampu  x1tex3D(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy);   // 3D non-proj, w/derivs
fragment clampu2 x2tex3D(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy);   // 3D non-proj, w/derivs
fragment clampu3 x3tex3D(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy);   // 3D non-proj, w/derivs
fragment clampu4 x4tex3D(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy);   // 3D non-proj, w/derivs

fragment float  f1texCUBE(uniform texobj tex, float3 s);                           // CUBE non-projective
fragment float2 f2texCUBE(uniform texobj tex, float3 s);                           // CUBE non-projective
fragment float3 f3texCUBE(uniform texobj tex, float3 s);                           // CUBE non-projective
fragment float4 f4texCUBE(uniform texobj tex, float3 s);                           // CUBE non-projective
fragment clampu  x1texCUBE(uniform texobj tex, float3 s);                           // CUBE non-projective
fragment clampu2 x2texCUBE(uniform texobj tex, float3 s);                           // CUBE non-projective
fragment clampu3 x3texCUBE(uniform texobj tex, float3 s);                           // CUBE non-projective
fragment clampu4 x4texCUBE(uniform texobj tex, float3 s);                           // CUBE non-projective

fragment float  f1texCUBE(uniform texobj tex, float4 sq);                          // CUBE projective
fragment float2 f2texCUBE(uniform texobj tex, float4 sq);                          // CUBE projective
fragment float3 f3texCUBE(uniform texobj tex, float4 sq);                          // CUBE projective
fragment float4 f4texCUBE(uniform texobj tex, float4 sq);                          // CUBE projective
fragment clampu  x1texCUBE(uniform texobj tex, float4 sq);                          // CUBE projective
fragment clampu2 x2texCUBE(uniform texobj tex, float4 sq);                          // CUBE projective
fragment clampu3 x3texCUBE(uniform texobj tex, float4 sq);                          // CUBE projective
fragment clampu4 x4texCUBE(uniform texobj tex, float4 sq);                          // CUBE projective

fragment float  f1texCUBE(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy); // CUBE non-proj, w/derivs
fragment float2 f2texCUBE(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy); // CUBE non-proj, w/derivs
fragment float3 f3texCUBE(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy); // CUBE non-proj, w/derivs
fragment float4 f4texCUBE(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy); // CUBE non-proj, w/derivs
fragment clampu  x1texCUBE(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy); // CUBE non-proj, w/derivs
fragment clampu2 x2texCUBE(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy); // CUBE non-proj, w/derivs
fragment clampu3 x3texCUBE(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy); // CUBE non-proj, w/derivs
fragment clampu4 x4texCUBE(uniform texobj tex, float3 s, float3 dsdx, float3 dsdy); // CUBE non-proj, w/derivs

// Integrate operator.
float3 integrate(float3 i);

// Unary operators
// [claforte]  ++ and -- won't work until inputs are treated as variables.
//float operator++(float input);
//float operator--(float input);
//useless operator: float operator+(float input);
float operator-(float input);

//clampu operator++(clampu input);
//clampu operator--(clampu input);
//useless operator: clampu operator+(clampu input);
//[claforte] uncomment this once clampu literals are supported.
//clampu operator-(clampu input)
//{
//    return 0;
//}
clampu operator-(clampu input);

bool operator!(bool input);

// Linear interpolator

float4 lerp (float4 a, float4 b, float afrac)
{
    return afrac * a + (1 - afrac) * b;
}

// Bilinear interpolator.
float4 bilerp (float4 v00, float4 v01, float4 v10,
           float4 v11, float frac0, float frac1)
{
    float4 v0 = lerp(v00, v01, frac0);
    float4 v1 = lerp(v10, v11, frac0);
    return lerp(v0, v1, frac1);
}



// TESTS
//
bool test1(clampu a, clampu b, float c, float d)
{
    bool b1, b2;
    b1 = b2 = a > b;
    b2 = b1 && (c > d || b2);
    return b1 || b2;
}

bool test2(clampu a, clampu b, float c, float d)
{
    bool b1 = a*b > -(b+a) || b > a;
    bool b2 = c <= d && !b1;
    return !b2;
}

void test3(float a, float b, out float o_a)
{
    o_a = a * b;
}

void test4(float a, float b, out float o_a, out float o_b)
{
    o_a = a*b;
    o_b = 3.1415926;
}

clampu test5(clampu a, clampu b, clampu c)
{
    a += b;
    a /= c + b;
    a -= c + b;
    a %= c + b;
    a *= c + b;
    b = c = a;
    return c;
}

float4 test6(float4 in)
{
    return in * { 0.0, 0, 1, -1.39 } / { 299292.2, -299292.2, 777, -888} / in;
}

void test7(float in1, float in2,
           out float out1, out float out2)
{
   out1 = in1;
   out2 = in2;
}

float test8(float a, float b)
{
   float temp1;
   float temp2;
   test7(a, b, temp1, temp2);

   return temp1 * temp2;
}

float2 test9(float4 in1)
{
    return in1@xy;
}

float3 test10(float3 in1)
{
    return in1 * 3.1415926@xxx;
}

float4 test11()
{
    return {0,1,2,3}@abgr;
}

float4 test12(uniform matrix4 modelview, uniform matrix4 projection, vertex float4 obj_pos)
{
    return projection * (modelview * obj_pos);
}

fragment float3 bump(float3 geom_norm, float2 uv, uniform texobj texture);

// generic light: acts as a place holder for actual lights.
//light_shader
void generic_light(out float3 Lcol, out float3 Ldir,
                 float3 surf_pos);

// Crappy point light. It has a position and a color, but no decay.
//light_shader
void point_light_vertex(out vertex float3 Lcol, out vertex float3 Ldir,
                 vertex float3 surf_pos, vertex float3 light_pos,
                 uniform matrix4 transform,
                 vertex float3 light_color, vertex float light_intensity,
                 fragment float4 light_decay, vertex float depthBias,
                 vertex float nearCP, vertex float farCP,
                 vertex float depthMapSize, vertex float useDepthMapShadows)
{
    Lcol = light_color;
    Ldir = normalize(surf_pos - light_pos);
    // TODO: decay.
}


// Crappy spot light.
void spot_light_vertex(out vertex float3 Lcol, out vertex float3 Ldir,
                 vertex float3 surf_pos, uniform matrix4 transform,
                 fragment float3 light_pos,
                 vertex float3 light_color, vertex float light_intensity,
                 vertex float4 light_decay,
                 vertex float light_exponent, vertex float light_cutOff,
                 vertex float cone_angle, vertex float penumbra_angle,
                 vertex float drop_off, vertex float depthBias,
                 vertex float nearCP, vertex float farCP,
                 vertex float depthMapSize, vertex float useDepthMapShadows,
                 vertex float proj_tex, uniform texobj color_tex )
{
    Lcol = light_color;
    Ldir = surf_pos;
    // TODO.    Ldir = normalize(surf_pos - light_pos);
    // TODO: decay.
}

// Crappy directional light.
void directional_light_vertex(out vertex float3 Lcol, out vertex float3 Ldir,
                  vertex float3 surf_pos,  uniform matrix4 transform,
                  vertex float3 light_direction, vertex float3 light_color,
                  vertex float light_intensity,
                  vertex float depthBias,
                  vertex float nearCP, vertex float farCP,
                  vertex float depthMapSize, vertex float useDepthMapShadows)
{
    Lcol = light_color;
    Ldir = surf_pos;
    // TODO.    Ldir = normalize(surf_pos - light_pos);
    // TODO: decay.
}


void point_light_fragment(out fragment float3 Lcol, out fragment float3 Ldir,
                 fragment float3 surf_pos, fragment float3 light_pos,
                 uniform matrix4 transform,
                 fragment float3 light_color, vertex float light_intensity,
                 fragment float4 light_decay, vertex float depthBias,
                 vertex float nearCP, vertex float farCP,
                 vertex float depthMapSize, vertex float useDepthMapShadows)
{
    Lcol = light_color;
    Ldir = normalize(surf_pos - light_pos);
    // TODO: decay.
}

void directional_light_fragment(out vertex float3 Lcol, out vertex float3 Ldir,
                  vertex float3 surf_pos,  uniform matrix4 transform,
                  vertex float3 light_direction, vertex float light_intensity,
                  vertex float3 light_color,
                  vertex float depthBias,
                  vertex float nearCP, vertex float farCP,
                  vertex float3 light_xyzRotation,
                  vertex float depthMapSize, vertex float useDepthMapShadows)
{
    Lcol = light_color;
    Ldir = surf_pos;
    // TODO.    Ldir = normalize(surf_pos - light_pos);
    // TODO: decay.
}

void spot_light_fragment(out vertex float3 Lcol, out vertex float3 Ldir,
                 vertex float3 surf_pos, uniform matrix4 transform,
                 fragment float3 light_pos,
                 vertex float3 light_color, vertex float light_intensity,
                 vertex float4 light_decay,
                 vertex float light_exponent, vertex float light_cutOff,
                 vertex float cone_angle, vertex float penumbra_angle,
                 vertex float drop_off, vertex float depthBias,
                 vertex float nearCP, vertex float farCP,
                 vertex float depthMapSize, vertex float useDepthMapShadows,
                 vertex float proj_tex, uniform texobj color_tex )
{
    Lcol = light_color;
    Ldir = surf_pos;
    // TODO.    Ldir = normalize(surf_pos - light_pos);
    // TODO: decay.
}

void ambient_light_vertex(out vertex float3 Lcol, out vertex float3 Ldir,
                vertex float3    surf_pos,
                vertex float3    light_pos,
                uniform float3    light_color,
                uniform float    light_intensity,
                uniform float    ambient_shade)
{
    Lcol = light_color;
    Ldir = normalize(surf_pos - light_pos);
}

void ambient_light_fragment(out fragment float3 Lcol, out fragment float3 Ldir,
                fragment float3    surf_pos,
                fragment float3 light_pos,
                uniform float3    light_color,
                uniform float    light_intensity,
                uniform float    ambient_shade)
{
    Lcol = light_color;
    Ldir = normalize(surf_pos - light_pos);
}

// TODO: reflect_uv should not have to be passed to parser when reflect_tex
//       arg is used.
void Maya_phong(out vertex float4 outHPOS, out fragment float3 outColor,
                uniform matrix3 testmatrix,
                vertex float3 surf_pos,
                uniform texobj bump_tex, float2 bump_uv,
                uniform texobj color_tex, float2 color_uv,
                uniform texobj incan_tex, float2 incan_uv,
                uniform texobj spec_exp_tex, float2 spec_exp_uv,
                uniform texobj transp_tex, float2 transp_uv,
                uniform texobj ambient_tex, float2 ambient_uv,
                uniform texobj reflectivity_tex, float2 reflectivity_uv,
                uniform texobj reflectedCol_tex, float2 reflectedCol_uv,
                uniform texobj diffuse_tex, float2 diffuse_uv,
                uniform float refractiveIndex)
{
    outHPOS = surf_pos@xxxx;
    outColor = surf_pos;
}